home *** CD-ROM | disk | FTP | other *** search
/ Kellogg's Amérique / Kellogg's Amérique / amazonie_en_danger.swf / scripts / fl / controls / List.as < prev    next >
Text File  |  2020-08-04  |  16KB  |  482 lines
  1. package fl.controls
  2. {
  3.    import fl.controls.listClasses.ICellRenderer;
  4.    import fl.controls.listClasses.ListData;
  5.    import fl.core.InvalidationType;
  6.    import fl.core.UIComponent;
  7.    import fl.managers.IFocusManagerComponent;
  8.    import flash.display.DisplayObject;
  9.    import flash.display.Sprite;
  10.    import flash.events.Event;
  11.    import flash.events.KeyboardEvent;
  12.    import flash.events.MouseEvent;
  13.    import flash.geom.Rectangle;
  14.    import flash.ui.Keyboard;
  15.    import flash.utils.Dictionary;
  16.    
  17.    public class List extends SelectableList implements IFocusManagerComponent
  18.    {
  19.       
  20.       private static var defaultStyles:Object = {
  21.          "focusRectSkin":null,
  22.          "focusRectPadding":null
  23.       };
  24.       
  25.       public static var createAccessibilityImplementation:Function;
  26.        
  27.       
  28.       protected var _labelField:String = "label";
  29.       
  30.       protected var _rowHeight:Number = 20;
  31.       
  32.       protected var _cellRenderer:Object;
  33.       
  34.       protected var _iconField:String = "icon";
  35.       
  36.       protected var _labelFunction:Function;
  37.       
  38.       protected var _iconFunction:Function;
  39.       
  40.       public function List()
  41.       {
  42.          _rowHeight = 20;
  43.          _labelField = "label";
  44.          _iconField = "icon";
  45.          super();
  46.       }
  47.       
  48.       public static function getStyleDefinition() : Object
  49.       {
  50.          return mergeStyles(defaultStyles,SelectableList.getStyleDefinition());
  51.       }
  52.       
  53.       public function get iconField() : String
  54.       {
  55.          return _iconField;
  56.       }
  57.       
  58.       protected function doKeySelection(param1:int, param2:Boolean, param3:Boolean) : void
  59.       {
  60.          var _loc4_:Boolean = false;
  61.          var _loc5_:int = 0;
  62.          var _loc6_:Array = null;
  63.          var _loc7_:int = 0;
  64.          var _loc8_:int = 0;
  65.          _loc4_ = false;
  66.          if(param2)
  67.          {
  68.             _loc6_ = [];
  69.             _loc7_ = lastCaretIndex;
  70.             _loc8_ = param1;
  71.             if(_loc7_ == -1)
  72.             {
  73.                _loc7_ = caretIndex != -1 ? int(caretIndex) : int(param1);
  74.             }
  75.             if(_loc7_ > _loc8_)
  76.             {
  77.                _loc8_ = _loc7_;
  78.                _loc7_ = param1;
  79.             }
  80.             _loc5_ = _loc7_;
  81.             while(_loc5_ <= _loc8_)
  82.             {
  83.                _loc6_.push(_loc5_);
  84.                _loc5_++;
  85.             }
  86.             selectedIndices = _loc6_;
  87.             caretIndex = param1;
  88.             _loc4_ = true;
  89.          }
  90.          else
  91.          {
  92.             selectedIndex = param1;
  93.             caretIndex = lastCaretIndex = param1;
  94.             _loc4_ = true;
  95.          }
  96.          if(_loc4_)
  97.          {
  98.             dispatchEvent(new Event(Event.CHANGE));
  99.          }
  100.          invalidate(InvalidationType.DATA);
  101.       }
  102.       
  103.       override protected function drawList() : void
  104.       {
  105.          var _loc1_:Rectangle = null;
  106.          var _loc2_:uint = 0;
  107.          var _loc3_:uint = 0;
  108.          var _loc4_:uint = 0;
  109.          var _loc5_:Object = null;
  110.          var _loc6_:ICellRenderer = null;
  111.          var _loc7_:Dictionary = null;
  112.          var _loc8_:Dictionary = null;
  113.          var _loc9_:Boolean = false;
  114.          var _loc10_:String = null;
  115.          var _loc11_:Object = null;
  116.          var _loc12_:Sprite = null;
  117.          var _loc13_:* = null;
  118.          listHolder.x = listHolder.y = contentPadding;
  119.          _loc1_ = listHolder.scrollRect;
  120.          _loc1_.x = _horizontalScrollPosition;
  121.          _loc1_.y = Math.floor(_verticalScrollPosition) % rowHeight;
  122.          listHolder.scrollRect = _loc1_;
  123.          listHolder.cacheAsBitmap = useBitmapScrolling;
  124.          _loc2_ = Math.floor(_verticalScrollPosition / rowHeight);
  125.          _loc3_ = Math.min(length,_loc2_ + rowCount + 1);
  126.          _loc7_ = renderedItems = new Dictionary(true);
  127.          _loc4_ = _loc2_;
  128.          while(_loc4_ < _loc3_)
  129.          {
  130.             _loc7_[_dataProvider.getItemAt(_loc4_)] = true;
  131.             _loc4_++;
  132.          }
  133.          _loc8_ = new Dictionary(true);
  134.          while(activeCellRenderers.length > 0)
  135.          {
  136.             _loc5_ = (_loc6_ = activeCellRenderers.pop() as ICellRenderer).data;
  137.             if(_loc7_[_loc5_] == null || invalidItems[_loc5_] == true)
  138.             {
  139.                availableCellRenderers.push(_loc6_);
  140.             }
  141.             else
  142.             {
  143.                _loc8_[_loc5_] = _loc6_;
  144.                invalidItems[_loc5_] = true;
  145.             }
  146.             list.removeChild(_loc6_ as DisplayObject);
  147.          }
  148.          invalidItems = new Dictionary(true);
  149.          _loc4_ = _loc2_;
  150.          while(_loc4_ < _loc3_)
  151.          {
  152.             _loc9_ = false;
  153.             _loc5_ = _dataProvider.getItemAt(_loc4_);
  154.             if(_loc8_[_loc5_] != null)
  155.             {
  156.                _loc9_ = true;
  157.                _loc6_ = _loc8_[_loc5_];
  158.                delete _loc8_[_loc5_];
  159.             }
  160.             else if(availableCellRenderers.length > 0)
  161.             {
  162.                _loc6_ = availableCellRenderers.pop() as ICellRenderer;
  163.             }
  164.             else if((_loc12_ = (_loc6_ = getDisplayObjectInstance(getStyleValue("cellRenderer")) as ICellRenderer) as Sprite) != null)
  165.             {
  166.                _loc12_.addEventListener(MouseEvent.CLICK,handleCellRendererClick,false,0,true);
  167.                _loc12_.addEventListener(MouseEvent.ROLL_OVER,handleCellRendererMouseEvent,false,0,true);
  168.                _loc12_.addEventListener(MouseEvent.ROLL_OUT,handleCellRendererMouseEvent,false,0,true);
  169.                _loc12_.addEventListener(Event.CHANGE,handleCellRendererChange,false,0,true);
  170.                _loc12_.doubleClickEnabled = true;
  171.                _loc12_.addEventListener(MouseEvent.DOUBLE_CLICK,handleCellRendererDoubleClick,false,0,true);
  172.                if(_loc12_["setStyle"] != null)
  173.                {
  174.                   for(_loc13_ in rendererStyles)
  175.                   {
  176.                      _loc12_["setStyle"](_loc13_,rendererStyles[_loc13_]);
  177.                   }
  178.                }
  179.             }
  180.             list.addChild(_loc6_ as Sprite);
  181.             activeCellRenderers.push(_loc6_);
  182.             _loc6_.y = rowHeight * (_loc4_ - _loc2_);
  183.             _loc6_.setSize(availableWidth + _maxHorizontalScrollPosition,rowHeight);
  184.             _loc10_ = itemToLabel(_loc5_);
  185.             _loc11_ = null;
  186.             if(_iconFunction != null)
  187.             {
  188.                _loc11_ = _iconFunction(_loc5_);
  189.             }
  190.             else if(_iconField != null)
  191.             {
  192.                _loc11_ = _loc5_[_iconField];
  193.             }
  194.             if(!_loc9_)
  195.             {
  196.                _loc6_.data = _loc5_;
  197.             }
  198.             _loc6_.listData = new ListData(_loc10_,_loc11_,this,_loc4_,_loc4_,0);
  199.             _loc6_.selected = _selectedIndices.indexOf(_loc4_) != -1;
  200.             if(_loc6_ is UIComponent)
  201.             {
  202.                (_loc6_ as UIComponent).drawNow();
  203.             }
  204.             _loc4_++;
  205.          }
  206.       }
  207.       
  208.       public function get iconFunction() : Function
  209.       {
  210.          return _iconFunction;
  211.       }
  212.       
  213.       public function set iconField(param1:String) : void
  214.       {
  215.          if(param1 == _iconField)
  216.          {
  217.             return;
  218.          }
  219.          _iconField = param1;
  220.          invalidate(InvalidationType.DATA);
  221.       }
  222.       
  223.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  224.       {
  225.          var _loc2_:int = 0;
  226.          if(!selectable)
  227.          {
  228.             return;
  229.          }
  230.          switch(param1.keyCode)
  231.          {
  232.             case Keyboard.UP:
  233.             case Keyboard.DOWN:
  234.             case Keyboard.END:
  235.             case Keyboard.HOME:
  236.             case Keyboard.PAGE_UP:
  237.             case Keyboard.PAGE_DOWN:
  238.                moveSelectionVertically(param1.keyCode,param1.shiftKey && _allowMultipleSelection,param1.ctrlKey && _allowMultipleSelection);
  239.                break;
  240.             case Keyboard.LEFT:
  241.             case Keyboard.RIGHT:
  242.                moveSelectionHorizontally(param1.keyCode,param1.shiftKey && _allowMultipleSelection,param1.ctrlKey && _allowMultipleSelection);
  243.                break;
  244.             case Keyboard.SPACE:
  245.                if(caretIndex == -1)
  246.                {
  247.                   caretIndex = 0;
  248.                }
  249.                doKeySelection(caretIndex,param1.shiftKey,param1.ctrlKey);
  250.                scrollToSelected();
  251.                break;
  252.             default:
  253.                _loc2_ = getNextIndexAtLetter(String.fromCharCode(param1.keyCode),selectedIndex);
  254.                if(_loc2_ > -1)
  255.                {
  256.                   selectedIndex = _loc2_;
  257.                   scrollToSelected();
  258.                }
  259.          }
  260.          param1.stopPropagation();
  261.       }
  262.       
  263.       override public function itemToLabel(param1:Object) : String
  264.       {
  265.          if(_labelFunction != null)
  266.          {
  267.             return String(_labelFunction(param1));
  268.          }
  269.          return param1[_labelField] != null ? String(param1[_labelField]) : "";
  270.       }
  271.       
  272.       public function get labelField() : String
  273.       {
  274.          return _labelField;
  275.       }
  276.       
  277.       override protected function moveSelectionVertically(param1:uint, param2:Boolean, param3:Boolean) : void
  278.       {
  279.          var _loc4_:int = 0;
  280.          var _loc5_:int = 0;
  281.          var _loc6_:int = 0;
  282.          _loc4_ = Math.max(Math.floor(calculateAvailableHeight() / rowHeight),1);
  283.          _loc5_ = -1;
  284.          _loc6_ = 0;
  285.          switch(param1)
  286.          {
  287.             case Keyboard.UP:
  288.                if(caretIndex > 0)
  289.                {
  290.                   _loc5_ = caretIndex - 1;
  291.                }
  292.                break;
  293.             case Keyboard.DOWN:
  294.                if(caretIndex < length - 1)
  295.                {
  296.                   _loc5_ = caretIndex + 1;
  297.                }
  298.                break;
  299.             case Keyboard.PAGE_UP:
  300.                if(caretIndex > 0)
  301.                {
  302.                   _loc5_ = Math.max(caretIndex - _loc4_,0);
  303.                }
  304.                break;
  305.             case Keyboard.PAGE_DOWN:
  306.                if(caretIndex < length - 1)
  307.                {
  308.                   _loc5_ = Math.min(caretIndex + _loc4_,length - 1);
  309.                }
  310.                break;
  311.             case Keyboard.HOME:
  312.                if(caretIndex > 0)
  313.                {
  314.                   _loc5_ = 0;
  315.                }
  316.                break;
  317.             case Keyboard.END:
  318.                if(caretIndex < length - 1)
  319.                {
  320.                   _loc5_ = length - 1;
  321.                }
  322.          }
  323.          if(_loc5_ >= 0)
  324.          {
  325.             doKeySelection(_loc5_,param2,param3);
  326.             scrollToSelected();
  327.          }
  328.       }
  329.       
  330.       public function set labelField(param1:String) : void
  331.       {
  332.          if(param1 == _labelField)
  333.          {
  334.             return;
  335.          }
  336.          _labelField = param1;
  337.          invalidate(InvalidationType.DATA);
  338.       }
  339.       
  340.       public function set rowCount(param1:uint) : void
  341.       {
  342.          var _loc2_:Number = NaN;
  343.          var _loc3_:Number = NaN;
  344.          _loc2_ = Number(getStyleValue("contentPadding"));
  345.          _loc3_ = _horizontalScrollPolicy == ScrollPolicy.ON || _horizontalScrollPolicy == ScrollPolicy.AUTO && _maxHorizontalScrollPosition > 0 ? Number(15) : Number(0);
  346.          height = rowHeight * param1 + 2 * _loc2_ + _loc3_;
  347.       }
  348.       
  349.       override protected function setHorizontalScrollPosition(param1:Number, param2:Boolean = false) : void
  350.       {
  351.          list.x = -param1;
  352.          super.setHorizontalScrollPosition(param1,true);
  353.       }
  354.       
  355.       public function set iconFunction(param1:Function) : void
  356.       {
  357.          if(_iconFunction == param1)
  358.          {
  359.             return;
  360.          }
  361.          _iconFunction = param1;
  362.          invalidate(InvalidationType.DATA);
  363.       }
  364.       
  365.       public function get labelFunction() : Function
  366.       {
  367.          return _labelFunction;
  368.       }
  369.       
  370.       override protected function moveSelectionHorizontally(param1:uint, param2:Boolean, param3:Boolean) : void
  371.       {
  372.       }
  373.       
  374.       override protected function setVerticalScrollPosition(param1:Number, param2:Boolean = false) : void
  375.       {
  376.          invalidate(InvalidationType.SCROLL);
  377.          super.setVerticalScrollPosition(param1,true);
  378.       }
  379.       
  380.       protected function calculateAvailableHeight() : Number
  381.       {
  382.          var _loc1_:Number = NaN;
  383.          _loc1_ = Number(getStyleValue("contentPadding"));
  384.          return height - _loc1_ * 2 - (_horizontalScrollPolicy == ScrollPolicy.ON || _horizontalScrollPolicy == ScrollPolicy.AUTO && _maxHorizontalScrollPosition > 0 ? 15 : 0);
  385.       }
  386.       
  387.       override protected function draw() : void
  388.       {
  389.          var _loc1_:* = false;
  390.          _loc1_ = contentHeight != rowHeight * length;
  391.          contentHeight = rowHeight * length;
  392.          if(isInvalid(InvalidationType.STYLES))
  393.          {
  394.             setStyles();
  395.             drawBackground();
  396.             if(contentPadding != getStyleValue("contentPadding"))
  397.             {
  398.                invalidate(InvalidationType.SIZE,false);
  399.             }
  400.             if(_cellRenderer != getStyleValue("cellRenderer"))
  401.             {
  402.                _invalidateList();
  403.                _cellRenderer = getStyleValue("cellRenderer");
  404.             }
  405.          }
  406.          if(isInvalid(InvalidationType.SIZE,InvalidationType.STATE) || _loc1_)
  407.          {
  408.             drawLayout();
  409.          }
  410.          if(isInvalid(InvalidationType.RENDERER_STYLES))
  411.          {
  412.             updateRendererStyles();
  413.          }
  414.          if(isInvalid(InvalidationType.STYLES,InvalidationType.SIZE,InvalidationType.DATA,InvalidationType.SCROLL,InvalidationType.SELECTED))
  415.          {
  416.             drawList();
  417.          }
  418.          updateChildren();
  419.          validate();
  420.       }
  421.       
  422.       override protected function configUI() : void
  423.       {
  424.          useFixedHorizontalScrolling = true;
  425.          _horizontalScrollPolicy = ScrollPolicy.AUTO;
  426.          _verticalScrollPolicy = ScrollPolicy.AUTO;
  427.          super.configUI();
  428.       }
  429.       
  430.       override public function get rowCount() : uint
  431.       {
  432.          return Math.ceil(calculateAvailableHeight() / rowHeight);
  433.       }
  434.       
  435.       override protected function initializeAccessibility() : void
  436.       {
  437.          if(List.createAccessibilityImplementation != null)
  438.          {
  439.             List.createAccessibilityImplementation(this);
  440.          }
  441.       }
  442.       
  443.       override public function scrollToIndex(param1:int) : void
  444.       {
  445.          var _loc2_:uint = 0;
  446.          var _loc3_:uint = 0;
  447.          drawNow();
  448.          _loc2_ = Math.floor((_verticalScrollPosition + availableHeight) / rowHeight) - 1;
  449.          _loc3_ = Math.ceil(_verticalScrollPosition / rowHeight);
  450.          if(param1 < _loc3_)
  451.          {
  452.             verticalScrollPosition = param1 * rowHeight;
  453.          }
  454.          else if(param1 > _loc2_)
  455.          {
  456.             verticalScrollPosition = (param1 + 1) * rowHeight - availableHeight;
  457.          }
  458.       }
  459.       
  460.       public function get rowHeight() : Number
  461.       {
  462.          return _rowHeight;
  463.       }
  464.       
  465.       public function set labelFunction(param1:Function) : void
  466.       {
  467.          if(_labelFunction == param1)
  468.          {
  469.             return;
  470.          }
  471.          _labelFunction = param1;
  472.          invalidate(InvalidationType.DATA);
  473.       }
  474.       
  475.       public function set rowHeight(param1:Number) : void
  476.       {
  477.          _rowHeight = param1;
  478.          invalidate(InvalidationType.SIZE);
  479.       }
  480.    }
  481. }
  482.